////
////  StageScene.swift
////  Z048
////
////  Created by remy on 2017/11/17.
////  Copyright © 2017年 remy. All rights reserved.
////
//
///// 方块数量
//private let maxNum = 16
///// 方块移动区域尺寸
//private let wrapSize = Size.screenWidth - 32
///// 方块间距
//private let spaceSize: CGFloat = 8
///// 方块尺寸
//private let nodeSize = (wrapSize - spaceSize * 3) / 4
///// 默认偏移,SKNode 默认 position 是 (0.0, 0.0)
//private let offsetSize = (nodeSize - wrapSize) / 2
//private let colorList = [0xFFEB3B,0xFFC107,0xFF9800,0xFF5722,0xCDDC39,0x8BC34A,0x4CAF50,0x009688,0x00BCD4,0x03A9F4,0x2196F3,0x3F51B5,0x673AB7,0x9C27B0,0x880E4F,0xb71c1c]
//
//private class Piece: SKShapeNode {
//    var at = 0
//    var num = 0
//    var power = 0
//    var isMerged = false
//    /// 按序号排列的固定方块位置
//    private static var points = Array<CGPoint?>(repeating: nil, count: maxNum)
//    
//    var color: UIColor {
//        return UIColor(colorList[power - 1])
//    }
//    
//    /// 方块背景
//    convenience init(_ at: Int) {
//        self.init(rectOf: CGSize(width: nodeSize, height: nodeSize), cornerRadius: 6)
//        self.at = at
//        self.position = Piece.point(at)
//        self.strokeColor = SKColor.clear
//        self.fillColor = SKColor.white.withAlphaComponent(0.1)
//    }
//    
//    /// 方块
//    convenience init(at: Int, num: Int = 2) {
//        self.init(rectOf: CGSize(width: nodeSize, height: nodeSize), cornerRadius: 6)
//        (self.at, self.num) = (at, num)
//        power = Int(log(Double(num)) / log(2.0))
//        self.position = Piece.point(at)
//        self.strokeColor = SKColor.clear
//        self.fillColor = color
//        self.alpha = 0
//        self.setScale(0.8)
//        let numLabel = Label("\(num)", nodeSize * 0.4)
//        if num > 8192 {
//            numLabel.text = "2"
//            let powerLabel = Label("\(power)", nodeSize * 0.2, .bottom)
//            powerLabel.horizontalAlignmentMode = .left
//            powerLabel.position = CGPoint(x: nodeSize * 0.12, y: nodeSize * 0.15)
//            self.addChild(powerLabel)
//        }
//        self.addChild(numLabel)
//    }
//    
//    // 12 13 14 15
//    // 8  9  10 11
//    // 4  5  6  7
//    // 0  1  2  3
//    /// 按序号生成固定方块位置
//    static func point(_ at: Int) -> CGPoint {
//        if let p = points[at] {
//            return p
//        }
//        let x = CGFloat(at % 4) * (nodeSize + spaceSize) + offsetSize
//        let y = CGFloat(at / 4) * (nodeSize + spaceSize) + offsetSize
//        let point = CGPoint(x: x, y: y)
//        points[at] = point
//        return point
//    }
//    
//    deinit {
//        Risac.print("Destroy ------> Location: \(at), Number: \(num)")
//    }
//}
//
//private class Label: SKLabelNode {
//    
//    convenience init(_ text: String) {
//        self.init(text, 32, .bottom)
//    }
//    
//    convenience init(_ text: String, _ fontSize: CGFloat, _ vMode: SKLabelVerticalAlignmentMode = .center) {
//        self.init(fontNamed: "AvenirNext-Medium")
//        self.text = text
//        self.fontSize = fontSize
//        self.fontColor = SKColor.white
//        self.verticalAlignmentMode = vMode
//    }
//}
//
//class StageScene: SKScene {
//    
////    private static var points = Array<CGPoint?>(repeating: nil, count: maxNum)
//    private static let maxNum: Int = 16
//    private static let offsetSize = (nodeSize - wrapSize) / 2
//    /// 空闲区域位置序号
//    private var freeIndexes = [Int]()
//    /// 按序号存放当前方块
//    private var pieces = Array<Piece?>(repeating: nil, count: maxNum)
//    /// 生成方块动作
//    private var makeNodeAction: SKAction!
//    /// 合并方块动作
//    private var mergePieceAction: SKAction!
//    /// 等待动作,大于其他动作持续时间
//    private var maxDuration: SKAction!
//    /// 上次随机生成方块的位置序号
//    private var lastRandomIndex = 0
//    /// 最高得分
//    private var bestScore: Int = 0
//    /// 当前得分
//    private(set) var score: Int = 0
//    /// 游戏是否结束
//    private(set) var isOver = false
//    /// 当前得分 SKLabelNode
//    private let scoreView = Label("0")
//    /// 最高得分 SKLabelNode
//    private let bestScoreView = Label("0")
//    /// 方块移动区域
//    private let blockStage = SKShapeNode(rectOf: BlockConstants.wrapSize, cornerRadius: 8)
//    /// 蒙层
//    private let mask = SKShapeNode(rectOf: CGSize(width: Size.screenWidth, height: Size.screenHeight))
//    
//    /// SKScene初始化
//    override func didMove(to view: SKView) {
//        // 初始化块区域
//        blockStage.position = UIScreen.center
//        blockStage.strokeColor = .clear
//        blockStage.fillColor = .clear
//        self.addChild(blockStage)
//        // 块区域手势
//        let directions: [UISwipeGestureRecognizer.Direction] = [.left, .right, .up, .down]
//        directions.forEach {
//            blockStage.rx
//        }
//        for d in direction {
//            let swipe = UISwipeGestureRecognizer(target: self, action: #selector(swipeAction(_:)))
//            swipe.direction = d
//            view.addGestureRecognizer(swipe)
//        }
//        
//        // 初始化当前得分区域
//        let scoreTitle = Label("score".localized)
//        scoreTitle.fontSize = 24
//        scoreTitle.position = CGPoint(x: Size.screenWidth / 4, y: UIScreen.center.y + wrapSize / 2 + 72)
//        self.addChild(scoreTitle)
//        scoreView.position = CGPoint(x: scoreTitle.position.x, y: UIScreen.center.y + wrapSize / 2 + 24)
//        self.addChild(scoreView)
//        
//        // 初始化蒙层
//        let bestScoreTitle = Label("bestScore".localized)
//        bestScoreTitle.fontSize = 24
//        bestScoreTitle.position = CGPoint(x: Size.screenWidth / 4 * 3, y: scoreTitle.position.y)
//        self.addChild(bestScoreTitle)
//        bestScoreView.position = CGPoint(x: bestScoreTitle.position.x, y: scoreView.position.y)
//        self.addChild(bestScoreView)
//        
//        // 初始化最高得分区域
//        mask.position = UIScreen.center
//        mask.strokeColor = SKColor.clear
//        mask.fillColor = SKColor.white.withAlphaComponent(0.6)
//        mask.isHidden = true
//        self.addChild(mask)
//        
//        // 初始化游戏结束提示
//        let gameOver = SKLabelNode(fontNamed: "AvenirNext-Bold")
//        gameOver.text = "ending".localized
//        gameOver.fontColor = FlatColor.midnightBlue
//        gameOver.fontSize = 40
//        mask.addChild(gameOver)
//        
//        // 初始化空闲区域,方块背景
//        for index in 0..<maxNum {
//            freeIndexes.append(index)
//            wrap.addChild(Piece(index))
//        }
//        
//        // 初始化动作
//        let fade = SKAction.fadeIn(withDuration: 0)
//        let wait1 = SKAction.wait(forDuration: 0.15)
//        let scale1 = SKAction.scale(to: 1.0, duration: 0.2)
//        scale1.timingMode = .easeIn
//        let wait2 = SKAction.wait(forDuration: 0.15)
//        let scale21 = SKAction.scale(to: 1.2, duration: 0.1)
//        scale21.timingMode = .easeIn
//        let scale22 = SKAction.scale(to: 1.0, duration: 0.1)
//        scale22.timingMode = .easeIn
//        makeNodeAction = SKAction.sequence([wait1,fade,scale1])
//        mergePieceAction = SKAction.sequence([wait2,fade,scale21,scale22])
//        maxDuration = SKAction.wait(forDuration: 0.36)
//        
//        // 获取最高得分
//        if let bestScore = Preference[.bestScore] {
//            self.bestScore = bestScore
//        } else if let bestScore = keychain[PreferenceKeys.bestScore.rawValue] {
//            self.bestScore = Int(bestScore)!
//        }
//        bestScoreView.text = "\(bestScore)"
//        if let score = Preference[.lastScore], score > 0 {
//            // 上次暂停继续游戏
//            if let lastPieces = Preference[.lastPieces] {
//                self.score = score
//                freeIndexes = [Int]()
//                for index in 0..<maxNum {
//                    let num = lastPieces[index]
//                    if num > 0 {
//                        let p = Piece(at: index, num: num)
//                        p.alpha = 1
//                        p.setScale(1)
//                        pieces[index] = p
//                        wrap.addChild(p)
//                    } else {
//                        freeIndexes.append(index)
//                    }
//                }
//            }
//        } else {
//            // 新游戏
//            randomPiece()
//            randomPiece()
//            self.run(maxDuration)
//        }
//        updateScore()
//    }
//    
//    /// 随机生成方块
//    private func randomPiece() {
//        guard freeIndexes.count > 0 else { return }
//        let i = Int(arc4random_uniform(UInt32(freeIndexes.count)))
//        lastRandomIndex = freeIndexes[i]
//        freeIndexes.remove(at: i)
//        let p = Piece(at: lastRandomIndex)
//        pieces[lastRandomIndex] = p
//        wrap.addChild(p)
//        p.run(makeNodeAction)
//    }
//    
//    /// 移动方块
//    private func movePiece(from: Piece, index: Int) {
//        pieces[from.at] = nil
//        from.at = index
//        let move = SKAction.move(to: Piece.point(index), duration: 0.15)
//        move.timingMode = .easeIn
//        from.run(move)
//        pieces[index] = from
//    }
//    
//    /// 方块合并
//    private func mergePiece(from: Piece, to: Piece) {
//        pieces[from.at] = nil
//        from.at = to.at
//        from.isMerged = true
//        let move = SKAction.move(to: Piece.point(to.at), duration: 0.15)
//        move.timingMode = .easeIn
//        let remove = SKAction.removeFromParent()
//        from.run(SKAction.sequence([move,remove])) {
//            to.removeAllActions()
//            to.removeFromParent()
//        }
//        let p = Piece(at: to.at, num: to.num * 2)
//        p.setScale(1)
//        wrap.addChild(p)
//        p.run(mergePieceAction)
//        pieces[to.at] = p
//    }
//    
//    /// 游戏结束判断,移动结束后没有空闲区域时调用
//    private func gameOverCheck(_ direction: UISwipeGestureRecognizer.Direction) -> Bool {
//        // s1:同向方块递进,s2:异向方块递进,offsetIndex:异向方块偏移
//        // 计算横向合并可能性(纵向移动结束)
//        var s1 = 1, s2 = 4, offsetIndex = lastRandomIndex % 4
//        // 计算纵向合并可能性(横向移动结束)
//        if direction == .left || direction == .right {
//            (s1, s2, offsetIndex) = (4, 1, lastRandomIndex / 4 * 4)
//        }
//        // 同向计算合并可能性,只针对新生成方块
//        for x in 0..<3 {
//            let index = offsetIndex + s2 * x
//            if let p = pieces[index], let pp = pieces[index+s2], p.num == pp.num {
//                return false
//            }
//        }
//        // 异向计算合并可能性
//        for x in 0..<4 {
//            let baseIndex = s2 * x
//            for y in 0..<3 {
//                let index = baseIndex + s1 * y
//                if let p = pieces[index], let pp = pieces[index+s1], p.num == pp.num {
//                    return false
//                }
//            }
//        }
//        return true
//    }
//    
//    /// 更新数据
//    private func updateScore(_ delayRefresh: Bool = false) {
//        if score > bestScore {
//            bestScore = score
//        }
//        // 是否等待动作完成
//        if delayRefresh {
//            self.run(maxDuration) {
//                [weak self] in
//                self?.updateView()
//            }
//        } else {
//            updateView()
//        }
//    }
//    
//    /// 更新显示数据
//    private func updateView() {
//        scoreView.text = "\(score)"
//        bestScoreView.text = "\(bestScore)"
//    }
//    
//    /// 游戏保存
//    func gameSave() {
//        guard !isOver && score > 0 else { return }
//        Preference[.bestScore] = bestScore
//        keychain[PreferenceKeys.bestScore.rawValue] = "\(bestScore)"
//        Preference[.lastScore] = score
//        var lastPieces = [Int]()
//        for index in 0..<maxNum {
//            if let p = pieces[index] {
//                lastPieces.append(p.num)
//            } else {
//                lastPieces.append(0)
//            }
//        }
//        Preference[.lastPieces] = lastPieces
//    }
//    
//    /// 游戏重置
//    func gameReset() {
//        guard !self.hasActions() else { return }
//        if isOver {
//            isOver = false
//            mask.isHidden = true
//        } else {
//            Preference[.bestScore] = bestScore
//            keychain[PreferenceKeys.bestScore.rawValue] = "\(bestScore)"
//            Preference[.lastScore] = 0
//            Preference[.lastPieces] = []
//        }
//        score = 0
//        freeIndexes = [Int]()
//        for index in 0..<maxNum {
//            freeIndexes.append(index)
//            if let p = pieces[index] {
//                p.removeFromParent()
//                pieces[index] = nil
//            }
//        }
//        updateScore()
//        randomPiece()
//        randomPiece()
//        self.run(maxDuration)
//    }
//    
//    /// 手势事件
//    func stageSwipe(direction: UISwipeGestureRecognizer.Direction) {
//        // 动作完成且游戏没有结束时继续
//        guard !self.hasActions() && !isOver else { return }
//        // s1:异向方块递进,s2:同向方块递进,offsetIndex:异向方块偏移
//        var s1 = 1, s2 = 4, offsetIndex = 0
//        if direction == .left || direction == .right {
//            (s1, s2) = (4, 1)
//        }
//        if direction == .up || direction == .right {
//            (s1, s2, offsetIndex) = (-s1, -s2, maxNum - 1)
//        }
//        var isMoveOrMerge = false
//        for x in 0..<4 {
//            let baseIndex = offsetIndex + s1 * x
//            var pieceList = [Piece]()
//            for y in 0..<4 {
//                let index = baseIndex + s2 * y
//                if let p = pieces[index] {
//                    // 终点序号为贴边位置
//                    var endIndex = baseIndex
//                    if pieceList.count > 0 {
//                        // 某方向上不是第一个则计算是否和前一个方块合并
//                        let lastPiece = pieceList.last!
//                        // 终点序号为前一个方块位置旁
//                        endIndex = lastPiece.at + s2
//                        // 分数一样且本次移动还没合并过时可以合并
//                        if lastPiece.num == p.num && !lastPiece.isMerged {
//                            // 终点序号为前一个方块位置
//                            endIndex = lastPiece.at
//                            score += p.num * 2
//                        }
//                    }
//                    pieceList.append(p)
//                    // 终点序号不等于当前方块序号代表有移动或发生合并
//                    guard endIndex != index else { continue }
//                    isMoveOrMerge = true
//                    if let pp = pieces[endIndex] {
//                        mergePiece(from: p, to: pp)
//                    } else {
//                        movePiece(from: p, index: endIndex)
//                    }
//                }
//            }
//        }
//        
//        // 有移动或发生合并时继续
//        guard isMoveOrMerge else { return }
//        
//        // 计算空闲区域
//        freeIndexes = [Int]()
//        for x in 0..<maxNum {
//            guard let _ = pieces[x] else {
//                freeIndexes.append(x)
//                continue
//            }
//        }
//        randomPiece()
//        
//        self.updateScore(true)
//        
//        /// 没有空闲区域时进入游戏结束判断
//        if freeIndexes.count == 0 {
//            isOver = gameOverCheck(direction)
//            if isOver {
//                // 游戏结束
//                self.run(maxDuration) {
//                    [weak self] in
//                    self?.mask.isHidden = false
//                }
//                Preference[.bestScore] = bestScore
//                keychain[PreferenceKeys.bestScore.rawValue] = "\(bestScore)"
//                Preference[.lastScore] = 0
//                Preference[.lastPieces] = []
//            }
//        }
//    }
//}
